{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Indoor HIIT 健身动作识别算法的开发与部署\n",
    "\n",
    "## Introduction\n",
    "**此notebook 介绍了一种基于手机内置传感器的健身动作识别算法的开发及部署过程。此算法的功能是根据手机内置加速度与角速度传感器获取的数据判断使用者当前的动作。经过对比不同模型在验证集上的表现，选择一维CNN网络直接处理原始数据，而不进行特征提取。算法在测试集上的的平均准确率为97.7% 部署阶段，实用Tensorflow Serving 将模型部署至服务器。并使用Flask Web框架搭建API服务接口，以供微信小程序调用并返回预测结果。**\n",
    "<img src=\"https://s1.ax1x.com/2020/06/16/NiouQA.png\" alt=\"NiouQA.png\" border=\"0\" width=70%/>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.数据收集\n",
    "\n",
    "### 1.1 Activities\n",
    "* **徒手侧平举**\n",
    "* **前后交叉小跑**\n",
    "* **开合跳**\n",
    "* **深蹲**\n",
    "\n",
    "\n",
    "###  1.2 Format\n",
    "  * **在1次采集中，使用者左手持手机，并连续做同一动作20s。 传感器取样率为50Hz，20ms采集一次数据。 小程序将收集到的数据以json格式发送至云服务器。**\n",
    "  * **采集阶段，有超过10位用户参与，每位用户都进行了4个动作的数据采集。为了保证算法的可泛化，除规定手持手机姿势外，不对用户设置其他规定。**\n",
    "  * **数据字段如下**\n",
    "  \n",
    "  \n",
    "| Data                    | Key words | Type   |\n",
    "| ----------------------- | --------- | ------ |\n",
    "| Acceleration X axis     | accx      | Array  |\n",
    "| Acceleration Y axis     | accy      | Array  |\n",
    "| Acceleration Z axis     | accz      | Array  |\n",
    "| Angular velocity X axis | gyrx      | Array  |\n",
    "| Angular velocity Y axis | gyry      | Array  |\n",
    "| Angular velocity Z axis | gyrz      | Array  |\n",
    "| UserID                  | Id        | string |\n",
    "| Number of actions       | number    | Int    |\n",
    "| Class of activity       | Activity  | Int    |\n",
    "|                         |           |        |\n",
    "\n",
    " * **所有数据均正常，且无缺失值**\n",
    " * **数据还包括用户的性别、身高、体重等信息。为使模型更好的泛化，仅选取六轴数据**\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. 数据加载与预处理"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **原始6轴数据存在较大的噪音，在训练算法之前，先将数据进行滤波，除去高频噪音。滤波器使用低通巴特沃滋滤波器**\n",
    "* **将数据分割为2.56s的窗口（128个数据点）其中窗口之间有50%的重合.**\n",
    "<img src=\"https://s1.ax1x.com/2020/06/17/NVv0mV.png\" alt=\"NVv0mV.png\" border=\"0\" width=50% />\n",
    "\n",
    "* **使用Python中的json包读取原始数据json文件，并将其转化为nmupy数组**\n",
    "* **在使用多元时间序列数据时，将数据结构化为以下格式：**\n",
    " [samples, timesteps, channels] 此处为 [1470,128,6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "import IPython\n",
    "import sys\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from pandas import Series,DataFrame\n",
    "from scipy import signal,fft\n",
    "import matplotlib.pyplot as plt\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We have 1470 rows or windows of data, each window has 128 observations with 6 channels\n"
     ]
    }
   ],
   "source": [
    "b, a = signal.butter(8, 0.2, 'lowpass') #initialize the filter\n",
    "file=[\"/root/HAR/data/ios519/activity1.json\",\n",
    "      \"/root/HAR/data/ios519/activity2.json\",\n",
    "      \"/root/HAR/data/ios519/activity3.json\",\n",
    "      \"/root/HAR/data/ios519/activity4.json\",\n",
    "      ]#file path\n",
    "total_data=[]\n",
    "label=[]\n",
    "for filepath in file:\n",
    "    with open(filepath) as f:\n",
    "        for line in f:# lines by lines\n",
    "            one= json.loads(line)\n",
    "            \n",
    "            for i in range(15):# \n",
    "                accx=signal.filtfilt(b, a,one[\"accx\"][50+i*64:i*64+178])#each window has 128 observations\n",
    "                accy=signal.filtfilt(b, a,one[\"accy\"][50+i*64:i*64+178])#and 50% overlap\n",
    "                accz=signal.filtfilt(b, a,one[\"accz\"][50+i*64:i*64+178])\n",
    "                gryx=signal.filtfilt(b, a,one[\"gryx\"][50+i*64:i*64+178])\n",
    "                gryy=signal.filtfilt(b, a,one[\"gryy\"][50+i*64:i*64+178])\n",
    "                gryz=signal.filtfilt(b, a,one[\"gryz\"][50+i*64:i*64+178])\n",
    "                activity=one[\"activity\"]                \n",
    "                \n",
    "                data=np.dstack((accx,accy,accz,gryx,gryy,gryz)).reshape((128,6))#128 datapoints with 6 channels\n",
    "                total_data.append((data,activity))\n",
    "            \n",
    "print(\"We have\" ,np.array(total_data).shape[0] ,\"rows or windows of data, each window has 128 observations with 6 channels\")\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1分割数据集\n",
    "**我们将整个数据集分为：训练集(60%)、验证集(20%)、测试集(20%)**\n",
    "\n",
    "\n",
    "* **训练集：仅用于模型训练**\n",
    "* **验证集：根据训练所得模型在验证集上的表现，调整参数、超参数。以获得最佳表现**\n",
    "* **测试集：仅用于最终模型测试**\n",
    "\n",
    "<img src=\"https://s1.ax1x.com/2020/06/16/NkYHMR.png\" alt=\"NkYHMR.png\" border=\"0\" width=60% />\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train data shpae is  (1176, 128, 6)\n",
      "Train label shpae is  (1176, 1)\n",
      "Validation data shpae is  (147, 128, 6)\n",
      "Validation label shpae is  (147, 1)\n",
      "Test data shpae is  (147, 128, 6)\n",
      "Test label shpae is  (147, 1)\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(22)\n",
    "np.random.shuffle(total_data)#！！！ shuffle the data （important）\n",
    "train=total_data[0:1176]#60%\n",
    "val=total_data[1176:1323]#20%\n",
    "test=total_data[1323:1471]#20%\n",
    "test_data=[]\n",
    "test_label=[]\n",
    "train_data=[]\n",
    "train_label=[]\n",
    "val_data=[]\n",
    "val_label=[]\n",
    "\n",
    "for i in range(len(test)):\n",
    "    test_data.append(test[i][0])\n",
    "    test_label.append([test[i][1]])\n",
    "for i in range(len(train)):\n",
    "    train_data.append(train[i][0])\n",
    "    train_label.append([train[i][1]])\n",
    "for i in range(len(val)):\n",
    "    val_data.append(val[i][0])\n",
    "    val_label.append([val[i][1]])\n",
    "test_data=np.array(test_data)\n",
    "test_label=np.array(test_label)\n",
    "train_data=np.array(train_data)\n",
    "train_label=np.array(train_label)\n",
    "val_data=np.array(val_data)\n",
    "val_label=np.array(val_label)\n",
    "print(\"Train data shpae is \",train_data.shape,)\n",
    "print(\"Train label shpae is \",train_label.shape,)\n",
    "print(\"Validation data shpae is \",val_data.shape,)\n",
    "print(\"Validation label shpae is \",val_label.shape,)\n",
    "print(\"Test data shpae is \",test_data.shape,)\n",
    "print(\"Test label shpae is \",test_label.shape,)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  2.1 数据集的分布\n",
    "**为了确保模型可以平均学习到4种动作的特征，必须确保训练集中4中动作的数据占比相似**\n",
    "\n",
    "**为了确保模型测试符合实际使用时情况，要是 验证集和测试集 4种动作占比相似**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "def class_breakdown(data):\n",
    "    # convert the numpy array into a dataframe\n",
    "    df = pd.DataFrame(data)\n",
    "# group data by the class value and calculate the number of rows\n",
    "    counts = df.groupby(0).size()\n",
    "# retrieve raw rows\n",
    "    counts = counts.values\n",
    "# summarize\n",
    "    for i in range(len(counts)):\n",
    "        percent = counts[i] / len(df) * 100\n",
    "        print('Class=%d, total=%d, percentage=%.3f' % (i+1, counts[i], percent))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train set:\n",
      "Class=1, total=360, percentage=30.612\n",
      "Class=2, total=265, percentage=22.534\n",
      "Class=3, total=281, percentage=23.895\n",
      "Class=4, total=270, percentage=22.959\n",
      "Validation set:\n",
      "Class=1, total=50, percentage=34.014\n",
      "Class=2, total=30, percentage=20.408\n",
      "Class=3, total=30, percentage=20.408\n",
      "Class=4, total=37, percentage=25.170\n",
      "Test set:\n",
      "Class=1, total=40, percentage=27.211\n",
      "Class=2, total=35, percentage=23.810\n",
      "Class=3, total=34, percentage=23.129\n",
      "Class=4, total=38, percentage=25.850\n"
     ]
    }
   ],
   "source": [
    "print(\"Train set:\")\n",
    "class_breakdown(train_label)\n",
    "print(\"Validation set:\")\n",
    "class_breakdown(val_label)\n",
    "print(\"Test set:\")\n",
    "class_breakdown(test_label)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**可以看到，4种动作在3个集上的分布较为平均 可以进行模型训练与测试**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. 特征选择与提取\n",
    "**标准分类算法不能直接应用于原始时间序列加速度计数据。相反，我们首先必须将原始时间序列数据转换为某些特征。我们将数据划分为2.56s的窗口，然后基于每个2.56秒的段中包含的128$\\times$6个读数生成特征。**\n",
    "\n",
    "\n",
    "**由于现有的数据为2.56s窗口内三轴加速度与三轴角速度，首先选择在时域上进行特征提取。 经过多次实验，比较不同特征对算法准确率的影响。选取特征为：**\n",
    "\n",
    "* **最大值**\n",
    "* **最小值**\n",
    "* **标准差**\n",
    "* **平均值**\n",
    "* **中位数**\n",
    "* **绝对中位差**\n",
    "\n",
    "**共提取36个特征. 用提取后的特征训练的SVM与Random Forest 分类器均有较好的表现**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def feature_extratction(raw_data):#function to extract features\n",
    "    Total_feature_data=[]\n",
    "    sample_num=raw_data.shape[0]\n",
    "    length=raw_data.shape[1]\n",
    "    channels=raw_data.shape[2]\n",
    "    for i in range(sample_num):\n",
    "        feature_arrray=[]\n",
    "        for j in range(channels):            \n",
    "            data_array=raw_data[i,:,j]\n",
    "            Max=np.max(data_array)\n",
    "            Min=np.min(data_array)\n",
    "            Avg=np.mean(data_array)\n",
    "            Mad=Series(data_array).mad()\n",
    "            Median=np.median(data_array)\n",
    "            Std=Series(data_array).std()\n",
    "            feature_arrray.extend([Max,Min,Avg,Mad,Median,Std])\n",
    "        Total_feature_data.append(feature_arrray)\n",
    "           \n",
    "    return np.array(Total_feature_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "Train_feature_data=feature_extratction(train_data)\n",
    "Val_feature_data=feature_extratction(val_data)\n",
    "Test_feature_data=feature_extratction(test_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. 选择模型\n",
    "\n",
    "**在这个任务中，我们所需要的模型应能够正确的通过2.56s内手机六轴的数据，识别出用户所做的动作。 我们希望看到模型可以尽可能多的识别出用户当前的动作。所以选择算法时，我们关心模型在测试集上的精确率(precision)与召回率（recall）。为了实现单一指标选择。我们引入二者的调和平均F-1 score作为判断指标**\n",
    "\n",
    "\n",
    "**实际部署中，时间也是需要考虑的因素。此处所选取的算法所需的预测时间均较短且无较大差别，故不将其计入判断指标**\n",
    "\n",
    "**在现有的研究中，SVM模型与Random forest模型在使用传感器的人体动作识别任务上有最优的表现<sup>1<sup>** \n",
    "    \n",
    "**在实际实验中，一维CNN网络在测试集上的表现最优。**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1 SVM\n",
    "**SVM模型本身是一个二值分类器，再多分类问题上，使用一对一法（one-versus-one）两两类之间构造1个分类器，在这个任务中共有4种分类，6个SVM分类器（one-against-one）**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.svm import SVC\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.model_selection import GridSearchCV, train_test_split\n",
    "from sklearn.metrics import accuracy_score,precision_score, recall_score, f1_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**实验过程为选取不同的训练参数，用训练集训练模型并检查在验证集上的表现。 目的为找出在验证集上表现最优的训练参数**\n",
    "\n",
    "\n",
    "\n",
    "**实验结果为：C=1 Kernel=RBF函数 tolerate=0.001**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,\n",
       "    decision_function_shape='ovo', degree=3, gamma='auto', kernel='rbf',\n",
       "    max_iter=-1, probability=False, random_state=None, shrinking=True,\n",
       "    tol=0.001, verbose=False)"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = Train_feature_data\n",
    "Y = np.squeeze(train_label)\n",
    "\n",
    "clf = SVC(C=1.0,  class_weight=None,\n",
    "    decision_function_shape='ovo',  gamma='auto', kernel='rbf',\n",
    "    max_iter=-1, probability=False, random_state=None, shrinking=True,\n",
    "    tol=0.001, verbose=False)\n",
    "clf.fit(X, Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Confusion Matrix & F1 Score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_svm=clf.predict(Test_feature_data)\n",
    "y_real=np.squeeze(test_label)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9661620966845589"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "import seaborn as sns\n",
    "C_svm=confusion_matrix(y_real, y_pred_svm,labels=[1,2,3,4])\n",
    "sns.set()\n",
    "f,ax=plt.subplots()\n",
    "C_svm = C_svm.astype('float') / C_svm.sum(axis=1)[:, np.newaxis] #normalize the confusion matrix\n",
    "sns.heatmap(C_svm,annot=True,ax=ax,cmap=\"Blues_r\") #plot the matrix\n",
    "\n",
    "ax.set_title('confusion matrix') #set title\n",
    "ax.set_xlabel('predict') # X label\n",
    "ax.set_ylabel('true') #Y label\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**SVM分类器的F1 score**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "F1 score: 0.9661620966845589\n"
     ]
    }
   ],
   "source": [
    "f1_svm=f1_score(y_real,y_pred_svm,labels=[1,2,3,4],average='macro')\n",
    "print(\"F1 score:\",f1_svm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2 Random Forest\n",
    "**随机森林在很多分类问题上表现良好，它是Bagging算法的特例，通过构建多棵分类树。每棵树生成一个分类结果，由投票法决定最终分类**\n",
    "\n",
    "**经过实验，随机森林算法在测试集上平均正确率均在95%以上。 以下为实验过程中准确率最高一组**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/root/anaconda3/envs/jupyter_notebook/lib/python3.7/site-packages/sklearn/ensemble/forest.py:245: FutureWarning: The default value of n_estimators will change from 10 in version 0.20 to 100 in 0.22.\n",
      "  \"10 in version 0.20 to 100 in 0.22.\", FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(6)\n",
    "rfc = RandomForestClassifier()\n",
    "rfc = rfc.fit(X, Y)\n",
    "y_pred_rfc=rfc.predict(Test_feature_data)\n",
    "y_real=np.squeeze(test_label)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Confusion Matrix & F1 Score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(30.5, 0.5, 'true')"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXUAAAEcCAYAAAA4BiRaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3deVxUZf//8RcMIowy4gYCmubObe6Ymlsq7ihaqYXeaZbmgppW7oqoWejtXS6pld1lt9ltftMUXDMyza00FwrMXUQQkn1fhvP7g59j0zAxJMMww+fZ4zwezplrzvmc0+HNxXXOnGOnKIqCEEIIm2Bv6QKEEEKUHQl1IYSwIRLqQghhQyTUhRDChkioCyGEDZFQF0IIGyKhLsqcoijMnz+fTp068dxzz/3t5Zw9e5YBAwaUYWWWExsbS/v27dFqtZYuRdg4O7lOXZS1s2fPMnv2bA4ePIharbZ0OWbXp08fVqxYwVNPPWXpUoSQnrooe3fv3sXLy6tSBLopCgoKLF2CqEQk1Cu5uLg4AgMD6dKlC507d2bZsmUAFBYWsnHjRnr37k3Xrl2ZM2cO6enpAMTExNCiRQt2797N008/TefOndm0aRMAO3fuZNGiRVy4cIH27duzbt06du3axQsvvKC33hYtWnD79m0Avv/+ewYPHkz79u3p0aMHH3/8MQBnzpyhZ8+eus9cv36df/7zn/j4+DBkyBC+/fZb3Xvz5s0jODiYSZMm0b59e0aOHEl0dHSx2/yg/q+++opevXrRqVMnvvjiCy5dusTQoUPx8fHR7QeA6OhoXnzxRTp37kznzp15/fXXSUtLA+DNN98kNjaWyZMn0759ez766CPd8nfu3MnTTz/NuHHjdPMKCgpISUmhZ8+ehIeHA5CZmUm/fv34+uuv//7/SCEeUESlVVBQoAwdOlR56623lMzMTCUnJ0f56aefFEVRlJ07dyq+vr5KdHS0kpGRoUybNk154403FEVRlDt37ijNmzdXFi5cqGRnZytRUVFKq1atlGvXrimKoihfffWV8vzzz+vW8+fXiqIozZs3V27duqUoiqJ069ZNt96UlBTll19+URRFUU6fPq306NFDURRFycvLU3x9fZVNmzYpubm5ysmTJ5V27dop169fVxRFUebOnat06tRJuXjxopKfn6/Mnj1bee2114rd7gf1L168WMnJyVGOHz+uPPHEE8qUKVOU+/fvK/fu3VO6dOminDlzRlEURbl165byww8/KLm5uUpiYqISEBCgrFixQre83r17KydOnDBY/ptvvqlkZmYq2dnZunn5+fmKoijK8ePHlaeeekq5f/++snDhQmX69Oml/v8nRHGkp16JXbp0iYSEBObMmYNaraZq1ar4+PgAEBoayvjx42nQoAHVqlVj9uzZ7N+/X28oITAwECcnJ1q2bEnLli25fPny36rDwcGBa9eukZGRQY0aNWjVqpVBm4sXL5KVlcWkSZNwdHSka9eu9O7dm3379una9OvXjzZt2uDg4MCwYcOIior6y/VOmzaNqlWr0r17d9RqNX5+ftSuXRt3d3d8fHyIjIwEoGHDhnTr1g1HR0dq1arFSy+9xE8//VTidk2fPh21Wo2Tk5PBe927d2fgwIGMHz+eo0ePEhwcXOLyhDCFhHolFhcXh6enJw4ODgbvJSQk4OXlpXvt5eVFQUEBiYmJunl16tTR/dvZ2ZmsrKy/Vce6dev4/vvv6d27N2PHjuX8+fPF1lOvXj3s7R8esp6ensTHxxdbj5OTU4n11K5dW/fvqlWrGrx+8PnExERmzZpFjx496NChA2+++SbJycklble9evX+8v1Ro0Zx5coVnn32WWrWrFni8oQwhYR6Jebh4UFcXFyxJ/Lc3Ny4e/eu7nVsbCwODg56wWcqZ2dncnJydK9///13vffbtGnDpk2bOHnyJL6+vrz22mvF1nPv3j0KCwt18+Li4nB3dy91PaW1Zs0a7Ozs2Lt3Lz///DOrV69GMeGiMTs7O6PvabVagoKCGD58OF988YXu/IIQj0pCvRJr06YNdevWZc2aNWRlZZGbm8u5c+cA8PPzY+vWrdy5c4fMzEzeffddBg0aVGyvviQtW7bk6tWrREVFkZuby/r163Xv5eXlsXfvXtLT06lSpQrVqlVDpVIVW6uzszNbtmwhPz+fM2fOEB4ezuDBg//+DjBRZmYmarUajUZDfHw8W7Zs0Xu/Tp063Llzp1TL3Lx5MwArV65kwoQJzJ07V65hF2VCQr0SU6lUbN68mdu3b9O7d2969uzJgQMHAHj22WcZNmwYY8eOpW/fvjg6OrJ48eK/tZ7HH3+cadOmMX78ePr370/Hjh313t+zZw99+vShQ4cO/O9//2PVqlUGy3B0dGTTpk0cO3aMLl26EBwczKpVq2jSpMnfqqk0AgMDiYyMxMfHh0mTJtG/f3+99ydNmsSmTZvw8fHRXbnzV3755Rc+/fRTQkJCUKlUTJw4EYAPP/zQLPWLykW+fCSEEDZEeupCCGFDJNSFEKKchYSE0KdPH1q0aMGVK1eKbaPVagkODsbX15d+/fqxc+dOk5YtoS6EEOWsb9++fP7553qXDf9ZaGgo0dHRHD58mB07drB+/XpiYmJKXLaEuhBClDMfHx88PDz+ss3+/fsZOXIk9vb21KpVC19fXw4ePFjiskt/fZoQQggDaWlpunsC/ZFGo0Gj0ZR6eQ++HPiAh4cH9+7dK/FzVhfq6bmFJTeqBNy6zLB0CRWHo7OlK6g48rItXUGFkn1+wyN9PqcUN9jcunUrGzYYri8wMJDp06c/Uh2lYXWhLoQQ5aU0F3yPGzeOESNGGMz/O710KOqZx8bG0qZNG8Cw526MhLoQQhihYHqq/91hFmMGDhzIzp076d+/PykpKRw5coTPP/+8xM/JiVIhhDBGKcVUCitWrKBnz57cu3ePl156iSFDhgAwceJEIiIiAPD396d+/fr079+fUaNGMW3aNBo0aFDisq3uG6Uypl5ExtT/QMbUH5IxdT2POqaemWd6PFZzNH4Dt/Ikwy9CCGFEYan6vBLqQghRsVnVOEYRCXUhhDDCCjNdQl0IIYyxrjOORSTUhRDCiNJc0lhRSKgLIYQR0lMXQggbIqEuhBA2RIZfhBDChkhPXQghbIgVZrqEuhBCGGWFqS6hLoQQRpTuNgEVg4S6EEIYYX2RLqEuhBDGWWGqS6gLIYQRckmjEELYECscUpdQF0IIY6ww0yXUH0hNTWF50CJOnzyJa01XAmfMZuAQP4N26Wlp/CtkJSd/OA7Ac6Nf4NWpgQDci4tl5PCheu2zs7N47fU5jB33kvk3ohzV1KjZHDSGvl1bkpiSyZJ1e9lx8Kyly3pkNTXObF44ir6dmxdt18b97Dh8odi2K6YNZrz/kwBs3fsTCzfsA6BpgzqsnOFHl9YNUdnbcy7qDq+v2cPV6N8BGDvEh80LR5Kdm69b1jOv/4fjP98w89aZn60dF1b2YDhAQl0n5K3lVKlShcNHj3Pl8mVmBk6mWYsWNGnaTK/dv1e/Q05ODqEHj5CUlMSUiS/h4enJsOHPUM/Dk+Nnzuna3o2JYYTfAPr49i/vzTG79+aPIi+/gIZ959O2RX12rZvCpSsxRN24Z+nSHsl7b44o2q5BwbRt7smuf0/g0tU4om7G67V7eUQXhvZqReex76IoCmHrJ3HzbiJbdp/G1cWZfcd+5dXlO0jPzGXBK/3YuXo87Uav1n3+zC+36TtpY3lvntnZ2nFhhZlefg+eTk5OJioqiqioKJKTk8trtSbJzsoi/Mg3TJ42A7W6Gu06dKTn073ZH7bXoO2x77/jxZdexsnZGU8vL/xHPMve3buKXe6+0D207+iDp5eXuTehXKmdHBnetx3BG/eRmZ3HyQs32Pd9BAF+T1q6tEeidqrC8N6tCf7gUNF2XbzFvuORBAzqYNB27OCOrN1+jLsJqcT+nsbaz7/nn34+AJyNvMPW0J9ITsumQFvI+i+O0aKRG7U06vLepHJli8eFmZ47bVZm76lHR0ezePFiIiMjcXNzAyAhIYF//OMfBAcH06hRI3OXUKLbt2+hUtnTsNHjunnNm7fk57M/Fdv+j3+SKYrC9WtXi223L3QPr7w6pWyLrQCaNXRDqy3kWnSCbl7Elbt079jUglU9umaP1UWrVbh2575uXsTVOLq3b2zQ1ruxOxFXY/XaeT/uXuxyu7drTNz9NJLSsnTz2jb34s6hpSSnZbH9wM+s3hqOVmvdD1W3xePCGnvqZg/1OXPmEBAQwCeffIK9fdEfBoWFhYSGhjJ37lx27Nhh7hJKlJ2VRfXqLnrzqlevTmZWpkHbp7r1YOt/PmLpindISrzP3q93kZNj+AT38+fOkpSYSN9+tjf0Ul1dldSMHL15qRnZuFRzslBFZaO6uiqpmcVsl7qqYVtn/X2QmplT7PZ7udXgvTdHMG9tqG7eD+dv0PGFfxF9L4V/NHbnv2+NpUCr5V9bvyvDrSl/tnhcWOMljWYffklJSWHYsGG6QAewt7fH39+f1NRUc6/eJM5qNRmZGXrzMjMzqaauZtD2jXkLqFrViWf8BvL6zGkMGDQYN/d6Bu3C9n5NH99+qItZhrXLyMpF86cfVE11J9L/FIjWpmi79ANcU82J9Kxcw7bZ+vtAU62qwfbXca1G6LqJfPDVSb78w8nWW7FJ3I5LRlEUfr1+j7c//oYRfdqU8daUP5s8Lqxw/MXsoe7q6kpYWJjBkMXevXvRaDTmXr1JGjZshLZAS/TtW7p5V367TOOmhn821qjhyop3VnPou+N8uTsMpVCh1ROt9drk5ORw5JtD+A0bbu7SLeLq7QQcHOxp8lhd3bzWzb2IuhFnwaoe3dXo33FQ2dOkQR3dvNbNPIs9yRd1I57WzTz02/3hZKqrizOh6yay79ivrPo0/C/XqyhgVwb1W5otHheFiulTRWH2UH/nnXfYuXMnnTt3ZujQoQwdOpTOnTvzf//3f7zzzjvmXr1JnNVqevv6svn99WRnZXHh/M98fzScwX7DDNrG3IkmJSUZrVbLiePH2PXVl7w8abJem6PfHsHFxQWfJzuX1yaUq6ycPPaEX2TJlCGonRzp2rYxfr3asD3sR0uX9kiycvLZc/QXlkzqj9qpCl3bNMKv5z/YfuBng7af7z/HjBd64llXg0cdDTMDevLfsKJL91yqVSV07SucvnSLxRsPGHy2f9cWuNWqDkDzhnWZN8GXsGOR5t24cmCLx4VSiv8qCjulnC7ETEpKIi6u6De2h4cHtWrV+lvLSc81z8mk1NQUli1ZxJlTJ6nh6sr0mUXXqZ8/d5YZU1/VXar4zaEDrFn1Nunp6TRs2Ijpr71O127d9ZYVOPkVWj3RmimBM81SK4BblxlmW7YpamrUfLB0DH26tCQpJZPFlrwe2dG5zBZVU+PMB4tG0efJ5iSlZrL4/aLr1Lu1e5yv332Zur0X6dq+FTiE8cOKruz4dO+PuuvUxwzuyJag58nMztP7C7XD8//iTnwKb8/w44VBHajuXJWEpHS+OPgzb398hIKyOFGaZ3h+pzxVqOMCyD6/4ZE+fz3B9P3ZxK3sjsNHUW6hXlbMFerWxtKhXqGUYahbPQuHekXzqKF+rRSh3rSChLp8+UgIIYywri5vEQl1IYQwwsoGMgAJdSGEMMr6Il1CXQghjLLCjrqEuhBCGFORLlU0lYS6EEIYY32ZLqEuhBDGWGGmS6gLIYQxhVY4qC6hLoQQxpgp02/evMm8efNISUnB1dWVkJAQg9uQJyYmMn/+fOLi4sjPz6dLly4sWrQIB4e/ju1ye0iGEEJYG3PdpDEoKIiAgAAOHTpEQEAAS5YsMWizefNmmjRpQmhoKKGhofz6668cPny4xGVLqAshhBGKYvqUlpZGTEyMwZSWlqa3zMTERCIjI/HzK3oGsp+fH5GRkSQlJem1s7OzIzMzk8LCQvLy8sjPz8fdvfgHsfyRDL8IIYQRpbmkcevWrWzYYHivmcDAQKZPn657HRcXh7u7OyqVCgCVSoWbmxtxcXF6NzqcOnUq06dPp3v37mRnZzNmzBg6duxYYh0S6kIIYUwpxlXGjRvHiBEjDOb/3edGHDx4kBYtWrB161YyMzOZOHEiBw8eZODAgX/5OQl1IYQwojQPv9BoNCYFuIeHB/Hx8Wi1WlQqFVqtloSEBDw8PPTabdu2jZUrV2Jvb4+Liwt9+vThzJkzJYa6jKkLIYQR5nhIRu3atfH29iYsLAyAsLAwvL29DZ4xUb9+fY4dOwZAXl4ep06dolmzZiUuX0JdCCGMMdPlL0uXLmXbtm0MGDCAbdu2ERwcDMDEiROJiIgAYMGCBZw7d46hQ4cyfPhwGjVqxKhRo0pctjwkw0rJQzL+QB6S8ZA8JEPPoz4k49yttJIb/X8dG1WMZy7LmLoQQhhhXV3eIhLqQghhhJUNZAAS6kIIYZT1RbqEuhBCGGWFHXUJdSGEMEYeklEO5KqPIsk/PdpZfVtSs1OgpUsQtsr6Mt36Ql0IIcqLFWa6hLoQQhijtcJBdQl1IYQwwgozXUJdCCGMkROlQghhQ0pzl8aKQkJdCCGMkJ66EELYEBlTF0IIGyJXvwghhA2R4RchhLAhVthRl1AXQghjJNSFEMKGFMrwixBC2I5CK+yqS6gLIYQRVpjpEupCCGGMDL8IIYQNkZ66EELYECvMdAl1IYQwRrHCrrqEuhBCGCG3CRBCCBtifZEuoS6EEEZZ4/CLvaULsCY1NWp2rJnI/ZNr+G3/MkYP9LF0SRbzxefbeGHUM/i0e4LFC+ZZuhyLkuPiIVvbF4WlmCoK6amXwnvzR5GXX0DDvvNp26I+u9ZN4dKVGKJu3LN0aeWurpsbE1+dyskTx8nNybV0ORYlx8VDtrYvpKduw9ROjgzv247gjfvIzM7j5IUb7Ps+ggC/Jy1dmkX49utPn76+uNZwtXQpFiXHxUO2uC8UxfSpopBQN1Gzhm5otYVci07QzYu4chfvxh4WrEpYmhwXD9nivtAqislTRSHDLyaqrq5KakaO3rzUjGxcqjlZqCJREchx8ZAt7ouKE9Wms2hPfejQoZZcfalkZOWi+dPBqanuRHpmjpFPiMpAjouHbHFfKIpi8lRRmL2nfu3aNaPvJScnm3v1Zebq7QQcHOxp8lhdrkf/DkDr5l5E3YizcGXCkuS4eMgW90VFuqrFVGYPdT8/P7y8vIr9TZaSkmLu1ZeZrJw89oRfZMmUIUwJ3k7bFvXx69WG3uPXWLo0iygoKECr1aItLERbqCU3NxeVSoWDQ+Ua0ZPj4iFb3Bfm6oDfvHmTefPmkZKSgqurKyEhITRq1Mig3f79+9m0aROKomBnZ8cnn3xCnTp1/nLZZv8J9PLyYvv27bi7uxu816tXL3OvvkzNXLmDD5aOITr8bZJSMpm5cofVXqr1qD76YBObN27Qvd4XupfJUwOZMm26BauyDDkuHrK1faEtNE+qBwUFERAQgL+/P3v27GHJkiV89tlnem0iIiLYsGEDW7dupW7duqSnp+Po6Fjiss0e6v379+fu3bvFhnq/fv3MvfoylZyWxajZH1m6jAphyrTplTLAiyPHxUO2ti/M8eSjxMREIiMj+eSTT4Ci0Yzly5eTlJRErVq1dO0+/fRTJkyYQN26dQFwcXExaflmD/W5c+cafW/RokXmXr0QQvxtpemop6WlkZaWZjBfo9Gg0Wh0r+Pi4nB3d0elUgGgUqlwc3MjLi5OL9SvX79O/fr1GTNmDFlZWfTr148pU6ZgZ2f3l3VUrgFQIYQohdJ01Ldu3cqGDRsM5gcGBjJ9eun/qtVqtfz222988skn5OXl8corr+Dp6cnw4cP/8nMS6kIIYURpHmc3btw4RowYYTD/j710AA8PD+Lj49FqtahUKrRaLQkJCXh46H9Jy9PTk4EDB+Lo6IijoyN9+/bl0qVLJYa6fKNUCCGMKM1tAjQaDfXr1zeY/hzqtWvXxtvbm7CwMADCwsLw9vbWG3qBorH2H374AUVRyM/P5/Tp07Rs2bLEmiXUhRDCiIJCxeSpNJYuXcq2bdsYMGAA27ZtIzg4GICJEycSEREBwJAhQ6hduzaDBw9m+PDhNG3alOeee67EZdspFemrUCZwbh9o6RIqhOSfDMfuKquaneSYEMXLPv9oPydrvr9hctvXezV+pHWVFRlTF0III8x0mbpZSagLIYQRVjaQAUioCyGEUdJTF0IIG1KR7pNuKgl1IYQwQnrqQghhQ6ywo17669QLCwtJSEgouaEQQli5QkUxeaooTA71tLQ0Xn/9ddq0aUP//v0B+Pbbb3n33XfNVpwQQlhSoWL6VFGYHOpBQUFUr16d8PBwqlSpAkD79u05cOCA2YoTQghLKs1tAioKk8fUT506xfHjx6lSpYru1o+1atUiMTHRbMUJIYQlmeshGeZkck/dxcXF4JmisbGxuhu4CyGErSksxVRRmBzqI0eOZMaMGZw+fZrCwkLOnz/P3Llzef75581ZnxBCWIw1nig1efhl4sSJODo6smzZMgoKCliwYAGjR49m3Lhx5qxPCCEspgJltclMDnU7OzvGjx/P+PHjzViOEEJUHFY4pF66E6XGdO3atUyKEUKIisSmb+i1cOFCvdfJycnk5+fj7u7Ot99+W+aFCSGEpRVUpDOgJjI51MPDw/Vea7VaNm3aRLVq1cq8qL9UtZzXV0HJgyEeSji1ztIlVBhuXWdYugSbYo099b/9ODuVSsXkyZPZsmVLWdYjhBAVhjVe0vhIN/Q6ceKE7otIQghha6yxp25yqPfq1UsvwLOzs8nLyyMoKMgshQkhhKVZYaabHuqrV6/We+3s7Mzjjz9O9erVy7woIYSoCKzxNgEmhbpWq2X9+vV8/PHHODo6mrsmIYSoEGx2+EWlUhETE0NhYUU6HSCEEOZlhZlu+tUv06ZNY+nSpdy9exetVkthYaFuEkIIW2TT935ZtGgRAHv27NHNUxQFOzs7oqKiyr4yIYSwsIoT1aYzOdTfeOMNBg0apDdPURQOHz5c5kUJIURFYI1j6iYPv2zcuBEvLy+9qX79+mzevNmc9QkhhMVoCxWTp4qixJ76gxt5abVaTp8+rfebKyYmpvxvEyCEEOXECjvqJYf6gxt55eXlsWDBAt18Ozs76tatqxtrF0IIW2ONwy8lhvqDG3nNmTOHVatWmb0gIYSoKCrQqIrJTD5RKoEuhKhsbLKnLoQQlZX1RbqEuhBCGFWRrmoxlYS6EEIYIcMvQghhQ6ww0//+k4+EEMLWmeveLzdv3mT06NEMGDCA0aNHc+vWLaNtb9y4Qdu2bQkJCTFp2RLqQghhhKKYPpVGUFAQAQEBHDp0iICAAJYsWVJsO61WS1BQEL6+viYvW4ZfhBDCiNKcKE1LSyMtLc1gvkajQaPR6F4nJiYSGRnJJ598AoCfnx/Lly8nKSmJWrVq6X32ww8/5OmnnyYrK4usrCyT6pCeuhBCGKGU4r+tW7fSt29fg2nr1q16y4yLi8Pd3R2VSgUUPa/Czc2NuLg4vXaXL1/mhx9+YPz48aWqudL21GtqnNm84Dn6dm5OYkomSzYdZMfhC8W2XTFtEOOHdQJga+hPLNxwAICmDeqwcvpgurRuiMrennNRMbz+7z1cjb4PgGMVFSumDuI537Y4VXXgy28u8sa/91Kgtf570NfUqNkcNIa+XVsW7b91e9lx8KylyypzqakpLA9axOlTJ3Gt6UrgjNkMHOxn0C49LY1/rVrJyR+OA/Dc6Bd4dUogAPfiYhk5Yqhe++zsLF6bPYex414y/0aUI1s7LkozrDJu3DhGjBhhMP+PvXRT5efns3jxYt5++21d+Juq0ob6e28MJ69AS8PBy2nb3JNda17i0tU4om7G67V7eXhnhvZsReexa1FQCFv3CjfvJrFl9xlcXZzYdzyKV1fsJD0zlwUv+7Jz1TjaPb8GgDde7E0H7/p0HPNvVPb2fPWv8cx7qS8rtnxjiU0uU+/NH0VefgEN+86nbYv67Fo3hUtXYoi6cc/SpZWpkJXLqVKlCoe/O86Vy5eZOX0yzZq3oEnTZnrt/r36HXJycgg9cISkpCSmTHoJDw9Phg1/hnoenhw/fU7X9m5MDCOGDqCPb//y3hyzs7XjojSXNP55mMUYDw8P4uPj0Wq1qFQqtFotCQkJeHh46Nr8/vvvREdHM2nSJKBoaEdRFDIyMli+fPlfLr9SDr+onaowvPcTBH9wmMzsPE5evMW+45EEDGpv0Hbs4I6s3X6Mu7+nEvt7Gmu3H+efQ3wAOBsZw9bQn0hOy6ZAW8j6/x2nRSM3amnUAAzu7s3GL0+QnJbN/ZRMNn55gnFDfcp1W81B7eTI8L7tCN64r2j/XbjBvu8jCPB70tKllansrCzCj3zD5GkzUKur0a5DR3r26s3+sL0GbY8d+44Xx7+Mk7Mznl5e+I94lr1f7yp2ufvC9tC+gw+eXl7m3oRyZYvHRaFi+mSq2rVr4+3tTVhYGABhYWF4e3vrjad7enpy5swZwsPDCQ8PZ9y4cYwaNarEQIdyCPXk5GQWLlzIhAkT+Pzzz/Xemz59urlXX6xmj9VFq1W4due+bl7E1Ti8G7sbtPVu7E7Etbg/tIvF+3HDdgDd2z1O3P00ktKKTmjY2RXdzfIBOzuo7+6KpppTWW2KRTRr6IZWW8i16ATdvIgrd/Fu7PEXn7I+t2/fQqWyp2Gjx3XzmrdoyY3r14pt/8denaIoXL92tdh2+0L34DdseNkWWwHY4nGhKIrJU2ksXbqUbdu2MWDAALZt20ZwcDAAEydOJCIi4pFqNvvwS1BQEPXr16dXr1588cUXnDp1ivfeew8HBwfu3Llj7tUXq7qzI6mZOXrzUjNzcFFXLb5tRo5+u2qG7bzq1uC9N4Yzb22Ybt7hU78xbXQ3vj93HZW9HVNHdQOK/lJI+9P6rUl1dVW9fQKQmpGNi5X/svqz7Owsqld30ZtXvXp1MrMyDdo+9VQPtv7nI5aueIekxPvs/XoXOTnZBu3O/3yWpMRE+vazvaEXWzwuzHWbgCZNmrBz506D+R999FGx7UvTATZ7T/327dvMmTOH/v378/CCEZsAABU5SURBVJ///Ie6devy6quvkpuba+5VG5WRnYfmT8GsqVaV9CzDmv7cVqN2Ij1Tv10d12qErnuZD3ad4stvLurmh3wazsXfYjnz2Uy++2gqe7//lbz8AhKSM8p4i8pXRlauwV8bmupOpFvxL6riODurycjU/3+VmZFJNbXhg2HemLeAqk5OPDN0IK/PnMaAQYNxc69n0C5s79f08e2HuphlWDtbPC7MdZ26OZk91PPy8nT/trOzIygoiObNmzNp0iSLBfvV6N9xUNnTpEFt3bzWTT2IuhFv0DbqRjytm3k+bNfMQ+9kqquLM6FrX2bf8UhWffqd3mdzcguYtWYPTYat5B/PriIpNYvzl+9SaIU3Cfqjq7cTcHCwp8ljdXXzWjf3IupG3F98yvo0bNgIbYGW6Nu3dPOuXLlM4yZNDdrWqOHKirdXcyj8OF/uDkMpVGj1RGu9Njk5ORz55hB+Q21v6AVs87gw1/CLOZk91Bs0aMBPP/2kN2/u3Lm0a9fuL78aa05ZOfnsOforSyb2R+1Uha5tGuLXsxXbD5w3aPv5gXPMeKEHnnU1eNRxYWZAT/67r+gSLRd1VULfe5nTl26zeONBg88++AzAk60eY/6Eviz/yPqvfMnKyWNP+EWWTBmC2smRrm0b49erDdvDfrR0aWXKWa2md19fNm9cT3ZWFhfO/8z3R8MZ7DfMoG3MnWhSUpLRarWc+OEYu776kpcnTtZrczT8CC4uLvg82bm8NqFc2eJxYY09dbOPqa9atUrvZOEDs2bNYujQocV8onzMXL2bDxaOJPrAEpJSs5i5ajdRN+Pp1rYRX787gbp9ir62u2X3GR73qsVP22YB8Gnoj2zZfQaAYU+3wqdVA7wbuzN2SEfdsju88G/uxKfwuFdtPg4aRd2a1YmJT2XxxgN8+2PxJ8+szcyVO/hg6Riiw98mKSWTmSt3WO1la39l3sIlLAtaRL/e3anh6sr8hUE0adqM8z+fZcbUV3WXKkZF/sqa1W+Tnp5Ow4aNWLFytcFlj2F7v2aIn3+xPw+2wtaOi4rUAzeVnWJlVTt3mWvpEiqGXMOTdZVVwql1li6hwnDrOsPSJVQo2ec3PNLne/77hMltj83u9kjrKiuV9stHQghRksJC6/v2t4S6EEIYYV3jGEUk1IUQwggrG50GJNSFEMIoK8x0CXUhhDBGeupCCGFDrPGLghLqQghhhBV21CXUhRDCGBl+EUIIG2KFmS6hLoQQxkhPXQghbIgVZrqEuhBCGCNXvwghhA2R4RchhLAhEupCCGFDrDDTJdSFEMIY6akLIYQN0Wol1IUQwmZYYUddQl0IIYyR4RchhLAhVpjpEupCCGGM9NTLg6OzpSuoGHIzLV1BheHWdYalS6gw7v6w1tIl2BQrzHQrDHUhhCgnhYWFli6h1CTUhRDCGOmpCyGE7ZAxdSGEsCES6kIIYUMk1IUQwoZIqAshhA1R5CEZQghhO8zVU7958ybz5s0jJSUFV1dXQkJCaNSokV6b999/n/3796NSqXBwcGDWrFn06NGjxGVLqAshhBHmCvWgoCACAgLw9/dnz549LFmyhM8++0yvTZs2bZgwYQLOzs5cvnyZsWPH8sMPP+Dk5PSXy7Y3S8VCCGELlFJMJkpMTCQyMhI/Pz8A/Pz8iIyMJCkpSa9djx49cHYu+gZ9ixYtUBSFlJSUEpcvPXUhhDCiND31tLQ00tLSDOZrNBo0Go3udVxcHO7u7qhUKgBUKhVubm7ExcVRq1atYpf99ddf89hjj1GvXr0S65BQF0III0pzm4CtW7eyYcMGg/mBgYFMnz79b9fw448/snbtWv7zn/+Y1F5CXQghjChNT33cuHGMGDHCYP4fe+kAHh4exMfHo9VqUalUaLVaEhIS8PDwMPjs+fPnefPNN9m4cSONGzc2qQ4JdSGEMKYUY+V/HmYxpnbt2nh7exMWFoa/vz9hYWF4e3sbDL1cunSJWbNmsW7dOlq1amVyHXKiVAghjFAUxeSpNJYuXcq2bdsYMGAA27ZtIzg4GICJEycSEREBQHBwMDk5OSxZsgR/f3/8/f357bffSly2nWJlX5ly7rnU0iVUDOn3LV2BqIDkfur6alVTPdLn64z/n8lt73/6/COtq6zI8IsQQhhhZX1eQEJdCCGMktsECCGEDZGeuhBC2BAJdSGEsCES6kIIYUusL9Mrb6jXdHFm89xh9O3UhMTULJZ8+C07jkQU23bFZF/GD+kAwNZ951m4+Rvde9nHlpKZnceDX+g7w39h6qq9AASO7MLUZztTu4aazOw8/i/8F+Zv+gat1vqeUP5nNTVqNgeNoW/XliSmZLJk3V52HDxr6bIsorLsi9TUFFYuW8yPp07i6urK5OmzGDDIz6Bdenoa765+m9MnjgPwzMjneWVyoO79EUN8SUpKRGVf9DWZ1m3bs3bjlvLZiFKSnroVeW/WYPIKtDQc/i/aNq3HrpAALl27R9St3/XavTysI0O7t6TzhM0oikLYv1/kZmwyW/Y+/KF9csJmbtxN+vMq2HfiN/574AKpGTnUdHFm+/JRTHu2M+u+PGX27TO39+aPIi+/gIZ959O2RX12rZvCpSsxRN24Z+nSyl1l2Rdr3llBFYcq7DtyjKu/Xeb1mVNo1rwFjZs002u39l/vkJOTza6wb0hOTmL65AnU8/DEz/8ZXZvV773Pk52fKu9NKLXS3PulorDIN0pTU1MtsVodtVMVhvf6B8FbviMzO4+TEdHsO/EbAQPaGrQdO7Ada3ec4u7vacTeT2ftjpP8c1A7k9ZzMzaZ1IwcAOzsoLBQobFX8XdhsyZqJ0eG921H8MZ9Rfvvwg32fR9BgN+Tli6t3FWWfZGdncV33x5m0tQZqNXVaNu+Iz169ubgvlCDtj8cP8rYcS/j5OyMh6cXfv7PELZnlwWqfnTm+kapOZk91C9fvswzzzzDc889x/Xr15k0aRI9e/akV69eREVFmXv1xWrWoDbawkKuxSTq5kVcj8e7UV2Dtt6N6hJx7WGPK+JaPN6P67c7sv4lbu5+g/+tGM1j9Vz13hvt25r4A/O5GzaX1k3d+Xiv9f9Z3qyhG1ptIdeiE3TzIq7cxbux4Q2JbF1l2RfRt29hr1LxWMNGunlNm7fgxvVrxbbXCzlFMWi3dOFcBvXpxsypr3D1ymVzlFw2zHA/dXMze6ivWLGCadOmMXbsWF555RX8/Py4ePEiQUFBhISEmHv1xaru7EhqRq7evNSMHFzUVYtvm/mwbWqmfjvf6Z/QYtR7tPvnBuLup7PrnQBUqoe7dceRCNwHvc0TAevYsucsCcmZZtii8lVdXVX3F8gDqRnZuFT76yey2KLKsi+ys7KoXr263rzq1V3IyjI8nrt07c5/P9lCZmYmd6JvE7Z3Nzk52br3l761il1h37B73xE6+DzJa9Mmkp5ueB/yikB66sXIzMykb9++DB8+HIBhw4YB0KdPH5Oe4mEOGdl5aKrpB7imWlXSs3JLbKtR67c7cfE2+QVaUjNyeH3dARp5uNKyYR2D5VyPSSLq5u+snT2kDLfEMjKyctH8KbQ01Z1Iz8wx8gnbVVn2hbNaTWamfoBnZmagVlczaDtrzgKqOlVl1PCBzJ0dSL8Bg3Fzf/hwh7btOuDk5ISTszPjJkyiuouGCz+fM/s2/B0S6sX448Z269ZN7z1LnYS4eicRB5U9Teo/HN9u3aSewUlSgKhbv9O6ifvDdk3rEXXTsN0DigJ22BX7nkplz+OeNR+h8orh6u0EHBzsafLYw2Go1s29iLoRZ8GqLKOy7IvHGjZCW1DAnehbunlXr/xG4yZNDdrWqOFK8Fur2ffNcbb/XyiFhYX8o1Vro8su+nmpOKGop1Br+lRBmD3Uvby8yMjIAIqGYh64d++e7vl75S0rJ589x6JYMqE3aqcqdH2iAX7dW7D90EWDtp8fvMiM0V3xrOOCR20XZo7uyn8PXACKxtvbNK2Hvb0d1ZwdCZk2gNj7aVy+XRT644d0oK5rUU+mZcO6vDm2O0fP3Sy/DTWTrJw89oRfZMmUIaidHOnatjF+vdqwPexHS5dW7irLvnB2VvN0n358tGkD2dlZXLzwM8e/D2fgkKEGbWPuRJOakoJWq+XUiWPs2b2T8a+8CsC9uFguXviZ/Pw8cnNz2bb1Y1JTkmnTtkN5b5JpFMX0qYKw2K13s7KyyM7Opnbt2qX6XFnderemizMfzPOnj09jktKyWfzBEXYciaBbm8f4etVY6g5cqWv71uR+jPcrOug+DftZd516rw6Ps272ELzqasjMyefML3eYv+kw12OKLm/8YJ4/A7o0o7qzI/dTsth19FeCP/6O3LyCR98AC996t6ZGzQdLx9CnS0uSUjJZbKPXZpuiIu0Lc956NzU1hZXBi/jx9ClquNZgyvTZDBjkx4WfzzJ7+quEnygaQjly+ABr//UO6RnpPPZYQ6bOeJ0uT3UH4Mb1qyyZ/yZ3Y+7gWNWRZs1bMm3m63j/4wmz1Pyot951HrbJ5LbZe6c80rrKitxP3VrJ/dRFMeR+6voeOdSHbjS5bXbo1EdaV1mptF8+EkKIEinW9+UjCXUhhDBGQl0IIWxIBbqqxVQS6kIIYYx1nXIEJNSFEMI4GX4RQggbIj11IYSwIdJTF0IIGyI9dSGEsCFy9YsQQtgQGX4RQggbUijDL0IIYTukpy6EEDZEQl0IIWyInCgVQggbIpc0CiGEDZHhFyGEsCHSUxdCCBsiPXUhhLAhVthTt7d0AUIIUWEVak2fSuHmzZuMHj2aAQMGMHr0aG7dumXQRqvVEhwcjK+vL/369WPnzp0mLVtCXQghjFEKTZ9KISgoiICAAA4dOkRAQABLliwxaBMaGkp0dDSHDx9mx44drF+/npiYmBKXLaEuhBDGKIrJU1paGjExMQZTWlqa3iITExOJjIzEz88PAD8/PyIjI0lKStJrt3//fkaOHIm9vT21atXC19eXgwcPlliy1Y2pZx9baukShBCVRPbP60xuu379ejZs2GAwPzAwkOnTp+tex8XF4e7ujkqlAkClUuHm5kZcXBy1atXSa+fp6al77eHhwb1790qsw+pCXQghKqJx48YxYsQIg/kajaZc65BQF0KIMqDRaEwKcA8PD+Lj49FqtahUKrRaLQkJCXh4eBi0i42NpU2bNoBhz90YGVMXQohyVLt2bby9vQkLCwMgLCwMb29vvaEXgIEDB7Jz504KCwtJSkriyJEjDBgwoMTl2ymKFV6IKYQQVuz69evMmzePtLQ0NBoNISEhNG7cmIkTJzJjxgxat26NVqtl2bJlnDhxAoCJEycyevToEpctoS6EEDZEhl+EEMKGSKgLIYQNkVAXQggbIqEuhBA2RK5TL4WbN28yb948UlJScHV1JSQkhEaNGlm6LIsICQnh0KFD3L17l9DQUJo3b27pkiwiOTmZOXPmEB0djaOjIw0bNmTZsmUGl6dVFlOnTiUmJgZ7e3vUajWLFy/G29vb0mVVKnL1Sym8+OKLPPvss/j7+7Nnzx6++uorPvvsM0uXZRFnz57Fy8uLMWPGsHnz5kob6ikpKfz222907twZKPpll5qaysqVKy1cmWWkp6fj4uICwJEjR3j//ffZvXu3hauqXGT4xUSm3oSnsvDx8TH4Blxl5Orqqgt0gHbt2hEbG2vBiizrQaADZGRkYGdnZ8FqKicZfjGRqTfhEZVXYWEhX3zxBX369LF0KRa1cOFCTpw4gaIobNmyxdLlVDrSUxeijCxfvhy1Ws3YsWMtXYpFvfXWWxw9epRZs2axatUqS5dT6Uiom+iPN+EBjN6ER1ROISEh3L59m/feew97e/mxAhg+fDhnzpwhOTnZ0qVUKnL0mcjUm/CIyufdd9/ll19+4f3338fR0dHS5VhMZmYmcXFxutfh4eHUqFEDV1dXC1ZV+cjVL6Vg7CY8ldGKFSs4fPgw9+/fp2bNmri6urJv3z5Ll1Xurl69ip+fH40aNcLJyQmA+vXr8/7771u4svJ3//59pk6dSnZ2Nvb29tSoUYO5c+fSqlUrS5dWqUioCyGEDZHhFyGEsCES6kIIYUMk1IUQwoZIqAshhA2RUBdCCBsioS5szrx583j33XeBohuPmfKwXiFshYS6sGk+Pj4cOnSoxHa7du3ihRdeKIeKhDAvCXVRoRUUFFi6BCGsioS6sIg+ffrwwQcfMHjwYDp16sT8+fPJzc3lzJkz9OzZkw8//JBu3boxf/58AL777jv8/f3x8fHh+eef5/Lly7plRUZGMmLECNq3b89rr71Gbm6u7r0Hy3sgLi6OwMBAunTpQufOnVm2bBnXr18nKCiICxcu0L59e3x8fMpvRwhRxiTUhcWEhoby8ccf880333Dz5k02btwIFH3dPDU1le+++47ly5fz66+/smDBApYtW8aZM2cYPXo0U6dOJS8vj7y8PKZNm4a/vz8//vgjAwcO5PDhw8WuT6vV8uqrr+Lp6Ul4eDjHjh1j8ODBNGnShODgYNq1a8f58+c5e/Zsee4GIcqUhLqwmDFjxuDh4YGrqytTpkzR3TvG3t6eGTNm4OjoiJOTE19++SWjR4+mbdu2qFQqRowYQZUqVbhw4QIXL14kPz+fcePGUaVKFQYOHEjr1q2LXd+lS5dISEhgzpw5qNVqqlatKr1yYXPkIRnCYv5422JPT08SEhIAqFmzJlWrVtW9Fxsby9dff822bdt08/Lz80lISMDOzg53d3e9J+x4enoWu764uDg8PT1xcJDDXtguObqFxfzxNq2xsbG4ubkBGDwCzcPDg8mTJzNlyhSDZfz444/Ex8ejKIruc7GxsTRo0MCgrYeHB3FxcRQUFBgEuzx2TdgKGX4RFrN9+3bu3btHSkqK7qRpcUaOHMn//vc/Ll68iKIoZGVlcfToUTIyMmjXrh0ODg589tlnFBQUcPjwYSIiIopdTps2bahbty5r1qwhKyuL3Nxczp07BxTdLz8+Pp68vDyzba8Q5UFCXViMn58fEyZMwNfXlwYNGhTbEwdo3bo1y5cvZ9myZXTq1In+/fuza9cuABwdHVm/fj27d++mU6dO7N+/n379+hW7HJVKxebNm7l9+za9e/emZ8+eHDhwAIAuXbrQtGlTunfvrvcgaSGsjdxPXVhEnz59WLFiBU899ZSlSxHCpkhPXQghbIiEuhBC2BAZfhFCCBsiPXUhhLAhEupCCGFDJNSFEMKGSKgLIYQNkVAXQggbIqEuhBA25P8B7SWxMz7EkEwAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "import seaborn as sns\n",
    "C_rfc=confusion_matrix(y_real, y_pred_rfc,labels=[1,2,3,4])\n",
    "sns.set()\n",
    "f,ax=plt.subplots()\n",
    "C_rfc = C_rfc.astype('float') / C_rfc.sum(axis=1)[:, np.newaxis] #normalize the confusion matrix\n",
    "sns.heatmap(C_rfc,annot=True,ax=ax,cmap=\"Blues_r\") #plot the matrix\n",
    "\n",
    "ax.set_title('confusion matrix') #set title\n",
    "ax.set_xlabel('predict') # X label\n",
    "ax.set_ylabel('true') #Y label"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Random Forest分类器的F1 score**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "F1 score : 0.9736951801155531\n"
     ]
    }
   ],
   "source": [
    "f1_rfc=f1_score(y_real_test,y_pred_rfc,labels=[1,2,3,4],average='macro')\n",
    "print(\"F1 score :\" ,f1_rfc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3 CNN\n",
    "**深度学习方法 已被证明可以在极少的数据特征工程或没有数据特征工程的情况下，提供具有挑战性的活动识别任务的最新结果[<sup>2</sup>](#refer-anchor-2)** **.在识别健身动作中，选取特征时需要进行多次实验，往往不能很快找到最佳特征。为此，我们引入一维卷积神经网络（CNN）处理时间序列数据。并自动学习其中的特征[<sup>3</sup>](#refer-anchor-3)**。 **进过多次调整CNN的不同参数、超参数。 我们得到了一个令人惊喜的结果**\n",
    "\n",
    "\n",
    "**神经网络表现往往优于普通机器学习算法[<sup>4</sup>](#refer-anchor-4)**\n",
    "\n",
    "<img src=\"https://s1.ax1x.com/2020/06/18/Ne1WV0.png\" alt=\"截屏2020 06 18 下午12.37.21\" border=\"0\" width=70%>\n",
    "\n",
    "**一维卷积神经网络（CNN）处理六轴数据[<sup>3</sup>](#refer-anchor-3)**\n",
    "<img src=\"https://s1.ax1x.com/2020/06/18/Nei81O.png\" alt=\"截屏2020 06 17 下午7.52.20\" border=\"0\" width=70%>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### One-Hot 向量\n",
    "**网络输出为长度为4的1位数组，4个数分别代表输入数据 被识别为四种动作的概率。 为训练网络及检验结果，我们将原有的label分类变为 one-hot向量的格式**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "def change(data_label):\n",
    "    m,n=data_label.shape[0],data_label.shape[1]\n",
    "    data_label_onehot=np.zeros((m,n,4))\n",
    "    for l in range(m):\n",
    "        if data_label[l]== [1.0]:\n",
    "            data_label_onehot[l]=[[1,0,0,0]]\n",
    "        elif data_label[l]== [2.0]:\n",
    "            data_label_onehot[l]=[[0,1,0,0]]\n",
    "        elif data_label[l]== [3.0]:\n",
    "            data_label_onehot[l]=[[0,0,1,0]]\n",
    "        elif data_label[l]== [4.0]:\n",
    "            data_label_onehot[l]=[[0,0,0,1]]\n",
    "    return np.array(data_label_onehot)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_label_onehot=change(train_label)\n",
    "test_label_onehot=change(test_label)\n",
    "val_label_onehot=change(val_label)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**整个网络由4个卷基层，2个Dropout层，2个全连接层组成。实验中，随着卷基层数的增加，模型在验证集上的表现不断提升。通过调整每一层的参数，最终得到了一个表现良好的网络。其最大的优点是可以直接处理时间序列数据，进行自动特征提取并识别分类[<sup>5</sup>](#refer-anchor-5)\n",
    "。**\n",
    "* **卷基层（Conv layer）：自动特征提取**\n",
    "* **Dropout层： 防止过拟合（overfitting）**\n",
    "* **全联接层（FC layer）：预测结果**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://s1.ax1x.com/2020/06/18/Nei39K.png\" alt=\"截屏2020 06 17 下午9.38.15\" border=\"0\" width=30%>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from keras import backend as K\n",
    "from keras.models import load_model, Model,Input\n",
    "from keras.layers import Conv1D,Dense,ZeroPadding1D,MaxPooling1D,AveragePooling1D,Dropout"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def HARmodel(input_shape):\n",
    "    X_input = Input(input_shape)\n",
    "    X=Conv1D(32,5,strides=1,activation='relu',name=\"Conv1D_1\")(X_input)\n",
    "    #X=AveragePooling1D(pool_size=1,strides=2, padding='valid')(X)\n",
    "    X=Conv1D(64,5,strides=2,activation='relu',name=\"Conv1D_2\")(X)\n",
    "    #X=MaxPooling1D(pool_size=1,strides=1, padding='valid')(X)\n",
    "    #X=ZeroPadding1D(padding=2)(X)\n",
    "    X=Conv1D(64,5,strides=4,activation='relu',name=\"Conv1D_3\")(X)\n",
    "    #X=MaxPooling1D(pool_size=2,strides=3, padding='valid')(X)\n",
    "    X=Conv1D(64,5,strides=16,activation='relu',name=\"Conv1D_4\")(X)\n",
    "    X=Dropout(0.5)(X)\n",
    "    #X=MaxPooling1D(pool_size=1,strides=2, padding='valid')(X)\n",
    "    X = Dense(128, activation='softmax', name='FC_1_softmax')(X)\n",
    "    X=Dropout(0.5)(X)\n",
    "    X = Dense(4, activation='softmax', name='FC_2_softmax')(X)\n",
    "    model = Model(inputs = X_input, outputs = X, name='HARModel')\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "harModel = HARmodel(train_data.shape[1:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**由于此任务为多分类问题，loss function选为CrossEntrop，优化器选为Adam，可以加快收敛速度。 具体超参数为 learning_rate=0.001,\n",
    "    beta_1=0.9,\n",
    "    beta_2=0.999,\n",
    "    epsilon=1e-07,\n",
    "    amsgrad=False,**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "harModel.compile(loss='categorical_crossentropy', optimizer='adam',metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**训练过程中，训练次数选为1500次，用Mini-batch的方式训练，batch size选为200**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "\n",
    "history=harModel.fit(train_data,train_label_onehot, epochs = 1500, batch_size = 200,validation_data=(val_data,val_label_onehot))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 训练过程的正确率曲线"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(history.history['accuracy'])\n",
    "plt.plot(history.history['val_accuracy'])\n",
    "plt.title('Model accuracy')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(['Train', 'val'], loc='upper left')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 训练过程的loss曲线"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(history.history['loss'])\n",
    "plt.plot(history.history['val_loss'])\n",
    "plt.title('Model loss')\n",
    "plt.ylabel('Loss')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(['Train', 'val'], loc='upper left')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**保存训练好的模型**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "#harModel.save(\"/root/HAR/data/ConvNet_v5_new.h5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**读取模型**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [],
   "source": [
    "harModel=load_model(\"/root/HAR/data/ConvNet_v3_new.h5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**评估模型，查看模型在测试集上的平均正确率与损失**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "147/147 [==============================] - 0s 2ms/step\n",
      "Model loss is 0.07067668966340776\n",
      "Model accuracy is 0.9931972622871399\n"
     ]
    }
   ],
   "source": [
    "preds =harModel.evaluate(x = test_data, y = test_label_onehot)\n",
    "print (\"Model loss is\",preds[0])\n",
    "print (\"Model accuracy is\",preds[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import confusion_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_raw=harModel.predict(test_data)\n",
    "zzz=np.squeeze(y_pred_raw)#np.argmax(yy,1)\n",
    "y_pred_cnn=list(np.argmax(zzz,1)+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_true=list(np.squeeze(test_label))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "C=confusion_matrix(y_true, y_pred_cnn,labels=[1,2,3,4])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(30.5, 0.5, 'true')"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "sns.set()\n",
    "f,ax=plt.subplots()\n",
    "C = C.astype('float') / C.sum(axis=1)[:, np.newaxis] #normalize the confusion matrix\n",
    "sns.heatmap(C,annot=True,ax=ax,cmap=\"Blues_r\") #plot the matrix\n",
    "\n",
    "ax.set_title('confusion matrix') #set title\n",
    "ax.set_xlabel('predict') # X label\n",
    "ax.set_ylabel('true') #Y label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "F1 score is  0.9933143162774113\n"
     ]
    }
   ],
   "source": [
    "f1_cnn=f1_score(tru,ttt,labels=[1,2,3,4],average='macro')\n",
    "print(\"F1 score is \",f1_cnn)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**算法每一层的详细信息**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"HARModel\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_1 (InputLayer)         (None, 128, 6)            0         \n",
      "_________________________________________________________________\n",
      "Conv1D_1 (Conv1D)            (None, 124, 32)           992       \n",
      "_________________________________________________________________\n",
      "Conv1D_2 (Conv1D)            (None, 60, 64)            10304     \n",
      "_________________________________________________________________\n",
      "Conv1D_3 (Conv1D)            (None, 14, 64)            20544     \n",
      "_________________________________________________________________\n",
      "Conv1D_4 (Conv1D)            (None, 1, 64)             20544     \n",
      "_________________________________________________________________\n",
      "dropout_1 (Dropout)          (None, 1, 64)             0         \n",
      "_________________________________________________________________\n",
      "fc4 (Dense)                  (None, 1, 128)            8320      \n",
      "_________________________________________________________________\n",
      "dropout_2 (Dropout)          (None, 1, 128)            0         \n",
      "_________________________________________________________________\n",
      "fc2 (Dense)                  (None, 1, 4)              516       \n",
      "=================================================================\n",
      "Total params: 61,220\n",
      "Trainable params: 61,220\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "harModel.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**算法流程**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import SVG\n",
    "from keras.utils.vis_utils import model_to_dot\n",
    "from keras.utils import plot_model\n",
    "plot_model(harModel, to_file='HappyModel.png',show_shapes=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.4 模型对比"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| 模型          | F1 score           |\n",
    "| ------------- | ------------------ |\n",
    "| SVM           | 0.9661620966845589 |\n",
    "| Random Forest | 0.9736951801155531 |\n",
    "| CNN           | 0.9931972622871399 |\n",
    "\n",
    "\n",
    "**我们的判断指标为F1 score，故选取一维CNN模型**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.动作计数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**在我们选取的4个动作中，每个动作的数据均有较明显的波峰波谷。 针对每个动作，选取其六轴数据中周期特征最明显的一个轴。 并通过实验确定动作周期的阈值**\n",
    "\n",
    "**实际部署时，手机端一次发送5.12s的数据，共256条数据**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(total_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 256, 6)"
      ]
     },
     "execution_count": 219,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b, a = signal.butter(8, 0.1, 'lowpass') \n",
    "fil=[\"/root/HAR/data/523ios/activity1.json\",\n",
    "     \"/root/HAR/data/523ios/activity2.json\",\n",
    "     \"/root/HAR/data/523ios/activity3.json\",\n",
    "     \"/root/HAR/data/523ios/activity4.json\",\n",
    "      ]\n",
    "chart_data=[]\n",
    "label=[]\n",
    "\n",
    "for filepat in fil:\n",
    "    \n",
    "    with open(filepat) as fi:\n",
    "\n",
    "        for lines in fi:\n",
    "            \n",
    "            ones= json.loads(lines)            \n",
    "            accX=signal.filtfilt(b, a,ones[\"x_acc\"][100:356])                \n",
    "            accY=signal.filtfilt(b, a,ones[\"y_acc\"][100:356])\n",
    "            accZ=signal.filtfilt(b, a,ones[\"z_acc\"][100:356])\n",
    "            gryX=signal.filtfilt(b, a,ones[\"x_gyr\"][100:356])\n",
    "            gryY=signal.filtfilt(b, a,ones[\"y_gyr\"][100:356])\n",
    "            gryZ=signal.filtfilt(b, a,ones[\"z_gyr\"][100:356])\n",
    "                #print(np.dstack((accX,accY,accZ,gryX,gryY,gryZ)).shape)\n",
    "                         \n",
    "#               label.append([activity])\n",
    "            data=list(np.dstack((accX,accY,accZ,gryX,gryY,gryZ)).reshape((256,6)))\n",
    "            chart_data.append(data)\n",
    "            #print(data.shape)\n",
    "        #print(len(one[\"gryy\"][128:256]))\n",
    "        \n",
    "        #data.append(json.loads(line))\n",
    "\n",
    "\n",
    "chart_data=np.array(chart_data)\n",
    "chart_label=[]\n",
    "\n",
    "chart_data.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**画出四个动作分别在每个轴上的数据，横向依次为X_acc，Y_acc,Z_acc,X_gyr,Y_gyr,Z_gyr.纵向为徒手侧平举、前后交叉小跑、开合跳、深蹲**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 24 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for n in range(24):\n",
    "    plt.subplot(4,6,n+1)\n",
    "    action=n//6\n",
    "    axis=n%6\n",
    "    plt.plot(chart_data[action,:,axis])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**经过实验，不同动作有不同的运动周期。且在不同的轴上也有较大区别**\n",
    "\n",
    "\n",
    "| 动作           | 选取轴 | 周期阈值 |\n",
    "| -------------- | ------ | -------- |\n",
    "| 徒手侧平举     | Y_acc  | 1300ms   |\n",
    "| 前后交叉小跑 | X_acc  | 600ms    |\n",
    "| 开合跳         | Y_acc  | 800ms    |\n",
    "| 深蹲           | Y_acc  | 1400ms   |\n",
    "\n",
    "**计数算法**\n",
    "<img src=\"https://s1.ax1x.com/2020/06/18/NmSuOs.png\" alt=\"NmSuOs.png\" border=\"0\" width=30% />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6.服务器部署\n",
    "### 6.1 配置服务器\n",
    "####  所需软件/环境\n",
    "* **基本Python环境**\n",
    "* **Flask**\n",
    "* **UWSGI**\n",
    "* **Nginx**\n",
    "* **Docker**\n",
    "* **Tensorflow Serving**\n",
    "**具体工作流程为**\n",
    "<img src=\"https://s1.ax1x.com/2020/06/18/Nm9JsJ.png\" alt=\"Nm9JsJ.png\" border=\"0\" width=80%/>\n",
    "\n",
    "\n",
    "**其中 在DOcker中运行的Tensorflow Serving 可以部署我们之前训练好的模型，并接受Flask客户端发来的数据，并将预测结果返回**\n",
    "\n",
    "### 服务器代码"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**predict 函数的功能为发送数据至Tensorflow Serving 并接收结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import time\n",
    "import string\n",
    "import random\n",
    "import json\n",
    "import requests\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from detecta import detect_peaks\n",
    "from scipy import signal\n",
    "from flask import Flask, request, redirect, url_for, render_template\n",
    "from flask_bootstrap import Bootstrap\n",
    "from keras.models import load_model,Model\n",
    "app = Flask(__name__)\n",
    "Bootstrap(app)\n",
    "\n",
    "\"\"\"\n",
    "Constants\n",
    "\"\"\"\n",
    "MODEL_URI = 'http://localhost:8501/v1/models/firstmodel:predict'\n",
    "OUTPUT_DIR = 'static'\n",
    "CLASSES = ['Cat', 'Dog']\n",
    "SIZE = 128\n",
    "\n",
    "\"\"\"\n",
    "Utility functions\n",
    "\"\"\"\n",
    "def predict(json_data):\n",
    "    total_data=[]\n",
    "    predict=[]\n",
    "    if (len(json_data[\"x_acc\"])>=256) & (len(json_data[\"y_acc\"])>=256) &(len(json_data[\"z_acc\"])>=256) &(len(json_data[\"x_gyr\"])>=256) &(len(json_data[\"y_gyr\"])>=256) &(len(json_data[\"z_gyr\"])>=256):\n",
    "        t=5\n",
    "    else:\n",
    "        t=4\n",
    "   \n",
    "    b, a = signal.butter(8, 0.2, 'lowpass')\n",
    "    for i in range(t):\n",
    "        accX=signal.filtfilt(b, a,json_data[\"x_acc\"][0+i*32:i*32+128])\n",
    "        accY=signal.filtfilt(b, a,json_data[\"y_acc\"][0+i*32:i*32+128])\n",
    "        accZ=signal.filtfilt(b, a,json_data[\"z_acc\"][0+i*32:i*32+128])\n",
    "        gryX=signal.filtfilt(b, a,json_data[\"x_gyr\"][0+i*32:i*32+128])\n",
    "        gryY=signal.filtfilt(b, a,json_data[\"y_gyr\"][0+i*32:i*32+128])\n",
    "        gryZ=signal.filtfilt(b, a,json_data[\"z_gyr\"][0+i*32:i*32+128])\n",
    "        data_one=np.dstack((accX,accY,accZ,gryX,gryY,gryZ)).reshape((128,6))\n",
    "        total_data.append(data_one)\n",
    "    total_data=np.array(total_data)\n",
    "    data=json.dumps({'instances': total_data.tolist()})\n",
    "    response = requests.post(MODEL_URI, data=data.encode(),timeout=1)\n",
    "  \n",
    "    result = json.loads(response.text)\n",
    "    print(result)\n",
    "    prediction = result['predictions']\n",
    "    zzz=np.squeeze(prediction)#np.argmax(yy,1)\n",
    "    ttt=list(np.argmax(zzz,1))\n",
    "    pre=np.argmax(np.bincount(ttt))\n",
    "\n",
    "    print(np.squeeze(pre))\n",
    "   \n",
    "    for j in range(len(ttt)):\n",
    "        ttt[j]=int(ttt[j]) \n",
    "    return int(np.squeeze(pre)),ttt\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**计数函数**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def number(json_data,activity):\n",
    "    data=[]\n",
    "    b, a = signal.butter(8,0.08, 'lowpass' )\n",
    "    if activity==0:\n",
    "        c=signal.filtfilt(b, a,json_data[\"y_acc\"][:256])\n",
    "        ind = detect_peaks(c,mph=0 ,mpd=65)#动作1 accy 【1】\n",
    "        return len(ind)\n",
    "    if activity==1:\n",
    "        c=signal.filtfilt(b, a,json_data[\"x_acc\"][:256])\n",
    "        ind = detect_peaks(c,mph=0 ,mpd=30)#动作2 accy 【1】\n",
    "        return len(ind)\n",
    "    if activity==2:\n",
    "        c=signal.filtfilt(b, a,json_data[\"y_acc\"][:256])\n",
    "        ind = detect_peaks(c,mph=-0.50 ,mpd=40)#动作3 accy 【1】\n",
    "        return len(ind)\n",
    "    if activity==3:\n",
    "        c=signal.filtfilt(b, a,json_data[\"y_acc\"][:256])\n",
    "        ind = detect_peaks(c ,mpd=70)#动作4 accy 【1】\n",
    "        return len(ind)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Flask框架的核心 接受小程序发来的数据，并将结果返回**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Routes\n",
    "\"\"\"\n",
    "@app.route('/', methods=['POST'])\n",
    "\n",
    "def check():\n",
    "    # 默认返回内容\n",
    "    return_dict= {'return_code': '200', 'return_info': 'success', 'result': False,'number':'0','all':list([0,0])}\n",
    "    # 判断传入的json数据是否为空\n",
    "    if request.get_data() is None:\n",
    "        return_dict['return_code'] = '5004'\n",
    "        return_dict['return_info'] = 'empty'\n",
    "        return json.dumps(return_dict, ensure_ascii=False)\n",
    "    # 获取传入的参数\n",
    "    get_Data=request.get_data()\n",
    "    # 传入的参数需要转化成json\n",
    "    get_Data=json.loads(get_Data)\n",
    "    prediction,all_act=predict(get_Data)\n",
    "    print(type(all_act))\n",
    "    num=number(get_Data,prediction)\n",
    "    return_dict['result']=prediction\n",
    "    return_dict['all']=all_act\n",
    "    return_dict['number']=int(num)\n",
    "    # 对参数进行操作\n",
    "    \n",
    " \n",
    "    return json.dumps(return_dict)\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    app.run(host=\"0.0.0.0\",port=5000,threaded=True)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7.后期改进\n",
    "**我们最终选取的算法虽然在测试集上表现良好，但在实际部署中识别结果不一定准确。所以，在小程序中收集了用户 性别、身高、体重等信息。如果识别有误，小程序会统计识别错误用户的信息。以供进一步算法调整**\n",
    "<img src=\"https://s1.ax1x.com/2020/06/18/NmizSf.png\" alt=\"NmizSf.png\" border=\"0\" width=20%/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8. Reference\n",
    "<div id=\"refer-anchor-1\"></div>\n",
    "\n",
    "- [1] [Improving Activity Recognition Accuracy in Ambient-Assisted Living Systems by Automated Feature Engineering](10.1109/ACCESS.2017.2684913)\n",
    "<div id=\"refer-anchor-2\"></div>\n",
    "\n",
    "- [2] [How to Model Human Activity From Smartphone Data](https://machinelearningmastery.com/how-to-model-human-activity-from-smartphone-data/)\n",
    "\n",
    "<div id=\"refer-anchor-3\"></div>\n",
    "\n",
    "- [3] [Deep learning algorithms for human activity recognition using mobile and wearable sensor networks: State of the art and research challenges](https://www.sciencedirect.com/science/article/abs/pii/S0957417418302136?via%3Dihub)\n",
    "\n",
    "\n",
    "<div id=\"refer-anchor-4\"></div>\n",
    "\n",
    "- [4] [Machine Learning Yearning-Andrew Ng](https://www.deeplearning.ai/machine-learning-yearning/)\n",
    "<div id=\"refer-anchor-5\"></div>\n",
    "\n",
    "- [5] [Sequential Human Activity Recognition Based on Deep Convolutional Network and Extreme Learning Machine Using Wearable Sensors](https://www.hindawi.com/journals/js/2018/8580959/)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
